package com.hu.system.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.hu.common.exception.ServiceException;
import com.hu.common.utils.SecurityUtils;
import com.hu.common.utils.StringUtils;
import com.hu.system.mapper.ProfitReturnMapper;
import com.hu.system.mapper.SysUserShopMapper;
import com.hu.system.domain.ProfitReturn;
import com.hu.system.domain.ProductInfo;
import com.hu.system.service.IProfitReturnService;
import com.hu.system.service.IProductInfoService;

/**
 * 回款明细Service业务层处理
 *
 * @author hu
 * @date 2025-01-21
 */
@Service
public class ProfitReturnServiceImpl implements IProfitReturnService {
    @Autowired
    private ProfitReturnMapper profitReturnMapper;

    @Autowired
    private SysUserShopMapper userShopMapper;

    @Autowired
    private IProductInfoService productInfoService;

    /**
     * 查询回款明细列表
     *
     * @param profitReturn 回款明细
     * @return 回款明细
     */
    @Override
    public List<ProfitReturn> selectProfitReturnList(ProfitReturn profitReturn) {
        Long userId = SecurityUtils.getUserId();

        // 管理员查看全部
        if (userId != null && SecurityUtils.isAdmin(userId)) {
            return profitReturnMapper.selectProfitReturnList(profitReturn);
        }

        // 普通用户根据店铺过滤
        // 保存分页参数（因为查询店铺ID会消耗分页参数）
        com.github.pagehelper.Page<?> page = PageHelper.getLocalPage();
        // 清除分页参数，让店铺ID查询不使用分页
        PageHelper.clearPage();
        List<Long> shopIds = userShopMapper.selectShopIdsByUserId(userId);
        // 恢复分页参数，让主查询使用分页
        if (page != null) {
            PageHelper.startPage(page.getPageNum(), page.getPageSize(), page.getOrderBy());
        }
        if (shopIds == null || shopIds.isEmpty()) {
            return new ArrayList<>();
        }

        // 设置店铺ID过滤条件
        profitReturn.getParams().put("shopIdList", shopIds);

        return profitReturnMapper.selectProfitReturnList(profitReturn);
    }

    /**
     * 查询回款明细
     *
     * @param returnId 回款明细主键
     * @return 回款明细
     */
    @Override
    public ProfitReturn selectProfitReturnByReturnId(Long returnId) {
        ProfitReturn profitReturn = profitReturnMapper.selectProfitReturnByReturnId(returnId);

        // 数据权限校验
        if (profitReturn != null) {
            Long userId = SecurityUtils.getUserId();
            if (userId != null && !SecurityUtils.isAdmin(userId)) {
                List<Long> shopIds = userShopMapper.selectShopIdsByUserId(userId);
                if (shopIds == null || !shopIds.contains(profitReturn.getShopId())) {
                    return null;
                }
            }
        }

        return profitReturn;
    }

    /**
     * 新增回款明细
     *
     * @param profitReturn 回款明细
     * @return 结果
     */
    @Override
    @Transactional
    public int insertProfitReturn(ProfitReturn profitReturn) {
        profitReturn.setCreateBy(SecurityUtils.getUsername());
        profitReturn.setDelFlag("0");
        return profitReturnMapper.insertProfitReturn(profitReturn);
    }

    /**
     * 修改回款明细
     *
     * @param profitReturn 回款明细
     * @return 结果
     */
    @Override
    @Transactional
    public int updateProfitReturn(ProfitReturn profitReturn) {
        // 数据权限校验
        ProfitReturn existingReturn = selectProfitReturnByReturnId(profitReturn.getReturnId());
        if (existingReturn == null) {
            return 0;
        }

        profitReturn.setUpdateBy(SecurityUtils.getUsername());
        return profitReturnMapper.updateProfitReturn(profitReturn);
    }

    /**
     * 批量删除回款明细
     *
     * @param returnIds 需要删除的回款明细主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteProfitReturnByReturnIds(Long[] returnIds) {
        // 数据权限校验
        Long userId = SecurityUtils.getUserId();
        if (userId != null && !SecurityUtils.isAdmin(userId)) {
            List<Long> shopIds = userShopMapper.selectShopIdsByUserId(userId);
            for (Long returnId : returnIds) {
                ProfitReturn profitReturn = profitReturnMapper.selectProfitReturnByReturnId(returnId);
                if (profitReturn == null || !shopIds.contains(profitReturn.getShopId())) {
                    return 0;
                }
            }
        }

        return profitReturnMapper.deleteProfitReturnByReturnIds(returnIds);
    }

    /**
     * 删除回款明细信息
     *
     * @param returnId 回款明细主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteProfitReturnByReturnId(Long returnId) {
        // 数据权限校验
        ProfitReturn existingReturn = selectProfitReturnByReturnId(returnId);
        if (existingReturn == null) {
            return 0;
        }

        return profitReturnMapper.deleteProfitReturnByReturnId(returnId);
    }

    /**
     * 导入回款明细数据
     *
     * @param profitReturnList 回款明细列表
     * @param updateSupport    是否更新支持
     * @param shopId           所属店铺ID
     * @return 导入结果消息
     */
    @Override
    @Transactional
    public String importProfitReturn(List<ProfitReturn> profitReturnList, boolean updateSupport, Long shopId) {
        if (profitReturnList == null || profitReturnList.isEmpty()) {
            throw new ServiceException("导入数据不能为空");
        }

        int successNum = 0;
        int failureNum = 0;
        StringBuilder failureMsg = new StringBuilder();
        
        // 用于批量插入的列表
        List<ProfitReturn> batchInsertList = new ArrayList<>();
        
        // 导入备注标识
        String importRemark = "【导入于 " + com.hu.common.utils.DateUtils.getTime() + "】";
        
        // 本批次已处理的SKU集合，避免重复插入product_info
        java.util.Set<String> processedSkus = new java.util.HashSet<>();
        
        // 记录产品操作统计
        int createdProductCount = 0;
        int updatedProductCount = 0;
        java.util.List<String> updatedProductDetails = new java.util.ArrayList<>();

        // 第一步：数据校验和预处理
        for (ProfitReturn profitReturn : profitReturnList) {
            try {
                // 校验必填字段
                if (StringUtils.isEmpty(profitReturn.getSku())) {
                    failureNum++;
                    failureMsg.append("<br/>第" + (successNum + failureNum) + "条：SKU编码不能为空");
                    continue;
                }

                // 检查产品是否存在，不存在则自动创建，存在则更新（使用用户选择的店铺）
                // 同一批次中相同SKU只处理一次，避免唯一键冲突
                ProductInfo product = null;
                if (!processedSkus.contains(profitReturn.getSku())) {
                    com.hu.system.domain.ProductOperationResult operationResult = productInfoService.getOrCreateProduct(
                        profitReturn.getSku(),
                        profitReturn.getProductName(),
                        profitReturn.getSkuAttr(),
                        null,  // skuCode为空时服务层会自动设置为sku
                        shopId
                    );
                    product = operationResult.getProduct();
                    processedSkus.add(profitReturn.getSku());
                    
                    // 统计产品操作
                    if (operationResult.getOperationType() == com.hu.system.domain.ProductOperationResult.OperationType.CREATED) {
                        createdProductCount++;
                    } else if (operationResult.getOperationType() == com.hu.system.domain.ProductOperationResult.OperationType.UPDATED) {
                        updatedProductCount++;
                        updatedProductDetails.add("SKU[" + profitReturn.getSku() + "]" + operationResult.getUpdateDescription());
                    }
                } else {
                    // 本批次已处理过该SKU，从数据库查询产品信息（按SKU和店铺ID查询）
                    product = productInfoService.selectProductInfoBySkuAndShopId(profitReturn.getSku(), shopId);
                }
                
                // 设置店铺ID为用户选择的店铺
                profitReturn.setShopId(shopId);
                
                // 从产品信息中补充字段（如果导入数据中没有）
                if (product != null) {
                    if (StringUtils.isEmpty(profitReturn.getProductName())) {
                        profitReturn.setProductName(product.getProductName());
                    }
                    if (StringUtils.isEmpty(profitReturn.getSkuAttr())) {
                        profitReturn.setSkuAttr(product.getSkuAttr());
                    }
                }

                // 如果销售数量为null，默认设置为1
                if (profitReturn.getSalesQuantity() == null) {
                    profitReturn.setSalesQuantity(1);
                }

                // 添加导入备注标识
                if (StringUtils.isEmpty(profitReturn.getRemark())) {
                    profitReturn.setRemark(importRemark);
                } else {
                    profitReturn.setRemark(profitReturn.getRemark() + " " + importRemark);
                }
                
                // 设置基础字段
                profitReturn.setDelFlag("0");
                profitReturn.setCreateBy(SecurityUtils.getUsername());
                
                // 添加到批量插入列表
                batchInsertList.add(profitReturn);
                successNum++;
                
            } catch (Exception e) {
                failureNum++;
                String msg = "<br/>" + (successNum + failureNum) + "、SKU[" + profitReturn.getSku() + "] 预处理失败：";
                failureMsg.append(msg + e.getMessage());
            }
        }

        // 第二步：批量插入（每500条一批）
        if (!batchInsertList.isEmpty()) {
            int batchSize = 500;
            for (int i = 0; i < batchInsertList.size(); i += batchSize) {
                int endIndex = Math.min(i + batchSize, batchInsertList.size());
                List<ProfitReturn> subList = batchInsertList.subList(i, endIndex);
                profitReturnMapper.batchInsertProfitReturn(subList);
            }
        }

        // 第三步：返回结果
        StringBuilder resultMsg = new StringBuilder();
        
        if (failureNum > 0) {
            resultMsg.append("导入完成！成功 " + successNum + " 条，失败 " + failureNum + " 条");
        } else {
            resultMsg.append("恭喜您，数据已全部导入成功！共 " + successNum + " 条");
        }
        
        // 添加产品操作统计
        if (createdProductCount > 0 || updatedProductCount > 0) {
            resultMsg.append("<br/><br/>【产品处理统计】");
            if (createdProductCount > 0) {
                resultMsg.append("<br/>新建产品：" + createdProductCount + " 个");
            }
            if (updatedProductCount > 0) {
                resultMsg.append("<br/>更新产品：" + updatedProductCount + " 个");
                if (!updatedProductDetails.isEmpty()) {
                    resultMsg.append("<br/>更新详情：");
                    for (String detail : updatedProductDetails) {
                        resultMsg.append("<br/>  · " + detail);
                    }
                }
            }
        }
        
        if (failureNum > 0) {
            resultMsg.append("<br/><br/>错误如下：");
            resultMsg.append(failureMsg.toString());
            throw new ServiceException(resultMsg.toString());
        } else {
            return resultMsg.toString();
        }
    }
}

